<?xml version="1.0" encoding="utf-8" ?> 
<Docs>
	<!-- XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX -->
	<!-- XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX -->
	<TestAssemblyAttribute>
		<Class>
			<ub>
				<showdoc level="public"/>
			</ub>
			<summary>
			The <see langword="TestAssemblyAttribute"/> is an optional attribute that allows you to explicitly declare that an assembly contains (or will contain) tests.
			</summary>
			<remarks>
			<para>
			The <see langword="TestAssemblyAttribute"/> is an optional attribute that can be applied to an assembly to explicitly declare that it contains (or will contain) tests that can be executed by HarnessIt. This attribute may be applied by adding it to an assembly's AssemblyInfo file.
			</para>
			<para>
			This attribute is most often used to apply an informational description to an assembly containing tests.
			</para>
			</remarks>
			<example>
			The following example shows the code necessary to apply the <see langword="TestAssemblyAttribute"/> to an assembly.
			<code>
using UnitedBinary.UnitTests.Framework;
/*
 * Apply the optional TestAssemblyAttribute in an assembly's AssemblyInfo.cs file.
 */
[assembly: TestAssembly("This is a test assembly.")]</code>
			</example>
			<seealso cref="T:System.Attribute"/>
		</Class>
		<ctor>
			<ub>
				<showdoc level="public"/>
			</ub>
			<overloads>Creates an instance of the <see cref="T:UnitedBinary.UnitTests.Framework.TestAssemblyAttribute"/> class.</overloads>
			<summary>
				Creates an instance of the <see cref="T:UnitedBinary.UnitTests.Framework.TestAssemblyAttribute"/> class with an empty description.
			</summary>
			<remarks>
			<para>
			Specifying <see cref="T:UnitedBinary.UnitTests.Framework.TestAssemblyAttribute"/> on an assembly is not required.
			</para>
			</remarks>
			<example>
			The following example shows the code necessary to apply the <see cref="T:UnitedBinary.UnitTests.Framework.TestAssemblyAttribute"/> to an assembly.
			<code>
using UnitedBinary.UnitTests.Framework;
/*
 * Apply the optional TestAssemblyAttribute in an assembly's AssemblyInfo.cs file.
 */
[assembly: TestAssembly]</code>
			</example>
		</ctor>
		<ctor_string>
			<ub>
				<showdoc level="public"/>
			</ub>
			<summary>
				Creates an instance of the <see cref="T:UnitedBinary.UnitTests.Framework.TestAssemblyAttribute"/> class with the specified assembly description.
			</summary>
			<param name="description">The test assembly description that will be displayed within HarnessIt.</param>
			<remarks>
			<para>
			Specifying <see cref="T:UnitedBinary.UnitTests.Framework.TestAssemblyAttribute"/> on an assembly is not required.  This constructor overload provides a way to associate a description with the marked assembly.
			</para>
			</remarks>
			<example>
			The following example shows the code necessary to apply the <see cref="T:UnitedBinary.UnitTests.Framework.TestAssemblyAttribute"/> to an assembly.
			<code>
using UnitedBinary.UnitTests.Framework;
/*
 * Apply the optional TestAssemblyAttribute in an assembly's AssemblyInfo.cs file.
 */
[assembly: TestAssembly("This is a test assembly.")]</code>
			</example>
		</ctor_string>
		<Description>
			<summary>
				Gets the attribute's description.
			</summary>
		</Description>
	</TestAssemblyAttribute>
	<!-- XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX -->
	<!-- XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX -->
	<TestClassAttribute>
		<Class>
			<ub>
				<showdoc level="public"/>
			</ub>
			<summary>
			The <see langword="TestClassAttribute"/> is an optional attribute that allows you to explicitly declare that a class contains (or will contain) tests.
			</summary>
			<remarks>
			<para>
			The <see langword="TestClassAttribute"/> is an optional attribute that can be applied to a class to explicitly declare that it contains (or will contain) tests that can be executed by HarnessIt. This attribute may be applied to a class by adding it immediately before the class definition.
			</para>
			<para>
			This attribute is most often used to apply an informational description to a class containing tests.
			</para>
			</remarks>
			<example>
			The following example shows the code necessary to apply the <see langword="TestClassAttribute"/> to a class.
			<code>
using System;
using UnitedBinary.UnitTests.Framework;

namespace MyNamespace
{
    /*
     * Apply the optional TestClassAttribute.
     */
    [TestClass("This is a test class.")]
    public class MyTestClass
    {
        // ... class definition ...
    }
}</code>
			</example>
			<seealso cref="T:System.Attribute"/>
		</Class>
		<ctor>
			<ub>
				<showdoc level="public"/>
			</ub>
			<overloads>Creates an instance of the <see cref="T:UnitedBinary.UnitTests.Framework.TestClassAttribute"/> class.</overloads>
			<summary>
				Creates an instance of the <see cref="T:UnitedBinary.UnitTests.Framework.TestClassAttribute"/> class with an empty description.
			</summary>
			<remarks>
			<para>
			Specifying <see cref="T:UnitedBinary.UnitTests.Framework.TestClassAttribute"/> on a class is not required.
			</para>
			</remarks>
			<example>
			The following example shows the code necessary to apply the <see langword="TestClassAttribute"/> to a class.
			<code>
using System;
using UnitedBinary.UnitTests.Framework;

namespace MyNamespace
{
    /*
     * Apply the optional TestClassAttribute.
     */
    [TestClass]
    public class MyTestClass
    {
        // ... class definition ...
    }
}</code>
			</example>
		</ctor>
		<ctor_string>
			<ub>
				<showdoc level="public"/>
			</ub>
			<summary>
				Creates an instance of the <see cref="T:UnitedBinary.UnitTests.Framework.TestClassAttribute"/> class with the specified class description.
			</summary>
			<param name="description">The test class description that will be displayed within HarnessIt.</param>
			<remarks>
			<para>
			Specifying <see cref="T:UnitedBinary.UnitTests.Framework.TestClassAttribute"/> on a class is not required.  This constructor overload provides a way to associate a description with the marked class.
			</para>
			</remarks>
			<example>
			The following example shows the code necessary to apply the <see langword="TestClassAttribute"/> to a class.
			<code>
using System;
using UnitedBinary.UnitTests.Framework;

namespace MyNamespace
{
    /*
     * Apply the optional TestClassAttribute.
     */
    [TestClass("This is a test class.")]
    public class MyTestClass
    {
        // ... class definition ...
    }
}</code>
			</example>
		</ctor_string>
		<Description>
			<summary>
				Gets the attribute's description.
			</summary>
		</Description>
	</TestClassAttribute>
	<!-- XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX -->
	<!-- XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX -->
	<TestExecutionModeAttribute>
		<Class>
			<ub>
				<showdoc level="public"/>
			</ub>
			<summary>
			The <see langword="TestExecutionModeAttribute"/> is an optional attribute that allows you to specify whether HarnessIt uses a new instance of the marked test class for each test method invocation.
			</summary>
			<remarks>
			<para>
			HarnessIt can execute tests within a test class in two ways: <see cref="T:UnitedBinary.UnitTests.Framework.TestExecutionModes">TestExecutionModes.Renew</see> mode and <see cref="T:UnitedBinary.UnitTests.Framework.TestExecutionModes">TestExecutionModes.Reuse</see> mode. The <see langword="TestExecutionModeAttribute"/> is the attribute that controls the mode in which a test class will execute.</para>
			<para>In <see langword="Renew"/> mode, HarnessIt will create a new instance of your test class for each test method that is invoked on the test class.</para>
			<para>In <see langword="Reuse"/> mode, HarnessIt will create one instance of your test class and use it for all test method invocations on the test class. <see langword="Reuse"/> mode is most often used in concert with the <see cref="T:UnitedBinary.UnitTests.Framework.TestOrderAttribute"/> class to ensure that certain test methods are executed in a specific order.</para></remarks>
			<example>
			The following example illustrates how to use the <see langword="TestExecutionModeAttribute"/> class and the <see cref="T:UnitedBinary.UnitTests.Framework.TestOrderAttribute"/> class to implement methods that run before and after all other test methods (marked by the <see cref="T:UnitedBinary.UnitTests.Framework.TestMethodAttribute"/> class).
			<code>
using System;
using System.IO;
using UnitedBinary.UnitTests.Framework;

namespace MyNamespace
{
    /*
     * Apply the optional TestExecutionModeAttribute and direct
     * HarnessIt to use Reuse mode. This will let us execute a
     * Startup test method before and a Shutdown test method after
     * our primary test methods are complete.
     */

    [TestExecutionMode(TestExecutionModes.Reuse)]
    public class OrderedTests
    {
        private StreamWriter writer;
        
        public OrderedTests() {}
        
        [TestOrder(TestOrderModes.First)]
        [TestMethod("Our Startup method")]
        public void Startup(ITest it)
        {
            // HarnessIt will catch any exceptions generated
            // if the attempt to open the file fails. Test execution
            // continues with the next TestMethod.

            writer = File.CreateText(@"c:\dev\apitests\output.txt");
            writer.AutoFlush = true;
        }
        
        [TestMethod("Test our functionality")]
        public void TestLotsOfStuff(ITest it)
        {
            // HarnessIt will catch any exceptions generated
            // if the attempt to writer to the file fails. Test execution
            // continues with the next TestMethod.

            it.RunTest(writer != null, "The StreamWriter is allocated.");
            writer.Write("WRITE TEXT");
            it.RunTest(writer.BaseStream.Length == "WRITE TEXT".Length,
                "Wrote text successfully!");
        }
        
        [TestOrder(TestOrderModes.Last)]
        [TestMethod("Our Shutdown method")]
        public void Shutdown(ITest it)
        {
            // HarnessIt will catch any exceptions generated
            // if the attempt to close the file fails. Test execution
            // continues with the next TestMethod.

            writer.Close();
        }
    }
}</code>
			</example>
			<seealso href="../ProgrammingTestOrder.html">Test Order and Stateful Testing</seealso>
			<seealso cref="T:UnitedBinary.UnitTests.Framework.TestExecutionModes"/>
			<seealso cref="T:UnitedBinary.UnitTests.Framework.TestOrderAttribute"/>
			<seealso cref="T:UnitedBinary.UnitTests.Framework.TestOrderModes"/>
			<seealso cref="T:UnitedBinary.UnitTests.Framework.TestMethodAttribute"/>
			<seealso cref="T:System.Attribute"/>
		</Class>
		<ctor_TestExecutionModes>
			<ub>
				<showdoc level="public"/>
			</ub>
			<summary>
			Creates an instance of the <see cref="T:UnitedBinary.UnitTests.Framework.TestExecutionModeAttribute"/> class that will direct HarnessIt to execute the marked class using the method specified by the <paramref name="mode"/> parameter.
			</summary>
			<remarks>
			<para>HarnessIt can execute tests within a test class in two ways: <see cref="T:UnitedBinary.UnitTests.Framework.TestExecutionModes">TestExecutionModes.Renew</see> mode and <see cref="T:UnitedBinary.UnitTests.Framework.TestExecutionModes">TestExecutionModes.Reuse</see> mode. This constructor specifies which mode HarnessIt will use to execute the class marked by the <see cref="T:UnitedBinary.UnitTests.Framework.TestExecutionModeAttribute"/> attribute.</para>
			<para>In <see langword="Renew"/> mode, HarnessIt will create a new instance of your test class for each test method that is invoked on the test class.</para>
			<para>In <see langword="Reuse"/> mode, HarnessIt will create one instance of your test class and use it for all test method invocations on the test class.</para>
			</remarks>
			<param name="mode">The mode that HarnessIt will use to execute the marked class.</param>
			<seealso cref="T:UnitedBinary.UnitTests.Framework.TestExecutionModes"/>
		</ctor_TestExecutionModes>
		<Mode>
			<summary>
				Gets the attribute's mode.
			</summary>
		</Mode>
	</TestExecutionModeAttribute>
	<!-- XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX -->
	<!-- XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX -->
	<TestExecutionModes>
		<Class>
			<ub>
				<showdoc level="public"/>
			</ub>
			<summary>
			The <see langword="TestExecutionModes"/> enumeration defines the execution modes that can be used by HarnessIt.
			</summary>
			<remarks>
			Use the <see langword="TestExecutionModes"/> enumeration to specify the mode that HarnessIt will use to execute a class marked with the <see cref="T:UnitedBinary.UnitTests.Framework.TestExecutionModeAttribute"/>.</remarks>
			<seealso cref="T:UnitedBinary.UnitTests.Framework.TestExecutionModeAttribute"/>
		</Class>
		<Renew>
			<ub>
				<showdoc level="public"/>
			</ub>
			<summary>
			<para>HarnessIt will create a new instance of your test class for each test method that is invoked on the marked test class.</para>
			<para>Using <see langword="Renew"/> will not allow you to persist any non-static data in your test object between test method invocations.</para>
			</summary>
		</Renew>
		<Reuse>
			<ub>
				<showdoc level="public"/>
			</ub>
			<summary>
			HarnessIt will create one instance of your test class and use it for all test method invocations on the marked test class.
			<para>Using <see langword="Reuse"/> will allow you to persist non-static data in your test object between test method invocations.</para>
			</summary>
		</Reuse>
	</TestExecutionModes>
	<!-- XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX -->
	<!-- XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX -->
	<TestMethodAttribute>
		<Class>
			<ub>
				<showdoc level="public"/>
			</ub>
			<summary>
			The <see langword="TestMethodAttribute"/> is the single most important attribute within the HarnessIt Test Framework. Use this attribute to mark the test methods that you want HarnessIt to execute.
			</summary>
			<remarks>
			<para>The <see langword="TestMethodAttribute"/> is used to mark methods that you wish HarnessIt to execute. The attribute may be applied to a method by adding it immediately before the method definition.</para>
			<para>
			Only methods marked with the <see langword="TestMethodAttribute"/> will be executed by HarnessIt. Test methods must have the form:</para>
			<code>public void <i>MethodName</i>(ITest it)</code>
			</remarks>
			<example>
			The following example illustrates the creation of two test methods.
			<code>
using System;
using UnitedBinary.UnitTests.Framework;

namespace MyNamespace
{
    public class Tests
    {
        public Tests() {}

        [TestMethod]
        public void FirstTestMethod(ITest it)
        {
            it.RunTest(2+2 == 4, "Addition works.");
        }

        [TestMethod("This is another test method")]
        public void SecondTestMethod(ITest it)
        {
            it.RunTest(2-2 == 0, "Subtraction works.");
        }

        // This method is not a test method. Although the signature
        // is correct, the method is not marked with the
        // TestMethodAttribute and will not be executed.
        
        public void ThirdTestMethod(ITest it)
        {
            it.WriteLine("I will never execute!");
        }
    }
}</code>
			</example>
			<seealso cref="T:UnitedBinary.UnitTests.Framework.TestMethodRecord"/>
			<seealso cref="T:System.Attribute"/>
		</Class>
		<ctor>
			<ub>
				<showdoc level="public"/>
			</ub>
			<overloads>Creates an instance of the <see cref="T:UnitedBinary.UnitTests.Framework.TestMethodAttribute"/> class.</overloads>
			<summary>
			Creates an instance of the <see cref="T:UnitedBinary.UnitTests.Framework.TestMethodAttribute"/> class with an empty description.</summary>
			<remarks>
			<para>Only methods marked with the <see cref="T:UnitedBinary.UnitTests.Framework.TestMethodAttribute"/> will be executed by HarnessIt. Test methods must have the form:</para>
			<code>public void <i>MethodName</i>(ITest it)</code>
</remarks>
			<example>
			The following example illustrates how to declare a test method.
			<code>
using System;
using UnitedBinary.UnitTests.Framework;

namespace MyNamespace
{
    public class Tests
    {
        public Tests() {}

        [TestMethod]
        public void ThisIsATest(ITest it)
        {
            it.RunTest(3+3 == 6, "Addition works.");
            it.RunTest(3-3 == 0, "Subtraction works.");
            it.RunTest(3*3 == 9, "Multiplication works.");
            it.RunTest(3/3 == 1, "Division works.");
        }
    }
}</code>
			</example>
			<seealso cref="T:UnitedBinary.UnitTests.Framework.TestMethodRecord"/>
		</ctor>
		<ctor_string>
			<ub>
				<showdoc level="public"/>
			</ub>
			<summary>
			Creates an instance of the <see cref="T:UnitedBinary.UnitTests.Framework.TestMethodAttribute"/> class with the specified method description.</summary>
			<remarks>
			<para>Only methods marked with the <see cref="T:UnitedBinary.UnitTests.Framework.TestMethodAttribute"/> will be executed by HarnessIt. Test methods must have the form:</para>
			<code>public void <i>MethodName</i>(TestMethodRecord tmr)</code>
</remarks>
			<example>
			The following example illustrates how to declare a test method.
			<code>
using System;
using UnitedBinary.UnitTests.Framework;

namespace MyNamespace
{
    public class Tests
    {
        public Tests() {}

        [TestMethod("This method tests basic arithmetic operations")]
        public void ThisIsATest(ITest it)
        {
            it.RunTest(3+3 == 6, "Addition works.");
            it.RunTest(3-3 == 0, "Subtraction works.");
            it.RunTest(3*3 == 9, "Multiplication works.");
            it.RunTest(3/3 == 1, "Division works.");
        }
    }
}</code>
			</example>
			<param name="description">The test method description that will be displayed within HarnessIt.</param>
			<seealso cref="T:UnitedBinary.UnitTests.Framework.TestMethodRecord"/>
		</ctor_string>
		<Description>
			<summary>
				Access to the description of this test method.
			</summary>
		</Description>
	</TestMethodAttribute>
	<!-- XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX -->
	<!-- XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX -->
	<TestMethodRecord>
		<Class>
			<ub>
				<showdoc level="public"/>
			</ub>
			<summary>
			The <see langword="TestMethodRecord"/> class is the interface between your test code and HarnessIt. <see langword="TestMethodRecord"/> provides the functionality for you to add comments to the test output, run tests, and register any expected exceptions.
			</summary>
			<remarks>
			<para>For each test method marked with the <see cref="T:UnitedBinary.UnitTests.Framework.TestMethodAttribute"/>, HarnessIt will invoke the test method and pass an instance of the <see langword="TestMethodRecord"/> class as an argument to the test method.</para>
			<para>The <see cref="M:UnitedBinary.UnitTests.Framework.TestMethodRecord.RunTest(System.Boolean,System.String)"/> method is used to execute your tests.</para>
			<para>The <see cref="M:UnitedBinary.UnitTests.Framework.TestMethodRecord.WriteLine(System.String)"/> method is used to add additional descriptive text to your test output.</para>
			<para>The <see href="UnitedBinary.UnitTests.Framework.TestMethodRecord.RegisterException.html">RegisterException</see> method is used to notify HarnessIt that a test's expected output will be to throw an <see cref="T:System.Exception"/>.</para>
			</remarks>
			<example>
			The following example illustrates the use of all <see langword="TestMethodRecord"/> methods.
			<code>
using System;
using System.IO;
using UnitedBinary.UnitTests.Framework;

namespace MyNamespace
{
    public class TMRTests
    {
        public TMRTests() {}

        [TestMethod("This method illustrates the TestMethodRecord facilities.")]
        public void TMRExpectExceptionTest(TestMethodRecord tmr)
        {
            string path = @"c:\dev\apitests\exception.txt";

            // Create a file. This file must exist for this test to succeed.

            tmr.WriteLine("The test file will be created at: " + path);
            StreamWriter writer = File.CreateText(path);
            writer.Close();

            if (!tmr.RunTest(File.Exists(path), "Test file created successfully."))
            {
                return;
            }

            // Mark the file as read-only.

            tmr.WriteLine("Mark the test file as ReadOnly.");
            File.SetAttributes(path, FileAttributes.ReadOnly);
            tmr.RunTest((File.GetAttributes(path) &amp; FileAttributes.ReadOnly) == FileAttributes.ReadOnly,
                "Our test file has the ReadOnly attribute set.");

            writer = null;

            // Now, we will try to open the ReadOnly file we created for writing, but the attempt
            // will cause an UnauthorizedAccessException to be thrown. Since we are expecting this 
            // exception and we WANT the exception to be considered a success, we register the 
            // UnauthorizedAccessException with HarnessIt by using tmr.RegisterException(). At any
            // point after the call to tmr.RegisterException, if an exception of the type that 
            // was registered is thrown, HarnessIt will consider an exception caught having the
            // same type as the registered type to be evidence of a successful test.

            tmr.WriteLine("We should not be able to open a ReadOnly file for writing. " + 
                "We should receive a System.UnauthorizedAccessException.");

            // Register the exception with RegisterException.

            tmr.RegisterException("Caught UnauthorizedAccessException.",
                typeof(UnauthorizedAccessException));

            // We will now try to open our test file for writing. The attempt should fail.

            try
            {
                // This will throw our expected exception.

                writer = File.AppendText(path);
            }
            finally
            {
                // If somehow the writer WAS opened, make sure to close the StreamWriter. To 
                // observe this behavior, comment out the File.SetAttributes call above.

                if (writer != null)
                {
                    writer.Close();
                    tmr.WriteLine("Closed the StreamWriter.");
                }

                // Clean up. Delete our test file.

                tmr.WriteLine("Deleting test file.");
                File.SetAttributes(path, FileAttributes.Normal);
                File.Delete(path);
            }
        }
    }
}</code>
			</example>
			<seealso cref="T:UnitedBinary.UnitTests.Framework.TestMethodAttribute"/>
		</Class>
		<ctor>
			<summary>
				Creates an instance of the <see cref="T:UnitedBinary.UnitTests.Framework.TestMethodRecord"/> class.
			</summary>
		</ctor>
		<RunTest>
			<ub>
				<showdoc level="public"/>
			</ub>
			<summary>
				The <see langword="RunTest"/> method is used to execute tests within a <see cref="T:UnitedBinary.UnitTests.Framework.TestMethodAttribute">test method</see>.</summary>
			<param name="assertion">A test which evaluates to a boolean value used to determine whether the test succeeded. When <paramref name="assertion"/> is <see langword="true"/> HarnessIt considers the test a success.</param>
			<param name="description">HarnessIt will display this description in the test results when the test is executed.</param>
			<remarks>
				<para>Each call to the <see langword="RunTest"/> method is considered one unit test for statistical purposes.</para>
				<para>The <see langword="RunTest"/> method is thread-safe.</para>
			</remarks>
			<returns>The value of the <paramref name="assertion"/> parameter.</returns>
			<example>
			The following example details the use of the <see langword="RunTest"/> method.
			<code>
using System;
using UnitedBinary.UnitTests.Framework;

namespace MyNamespace
{
    public class Tests
    {
        public Tests() {}

        [TestMethod]
        public void ThisIsATest(TestMethodRecord tmr)
        {
            tmr.RunTest(3+3 == 6, "Addition works.");
            tmr.RunTest(3-3 == 0, "Subtraction works.");
            tmr.RunTest(3*3 == 9, "Multiplication works.");
            tmr.RunTest(3/3 == 1, "Division works.");
        }
    }
}</code>
			</example>
			<seealso cref="T:UnitedBinary.UnitTests.Framework.TestMethodAttribute"/>
		</RunTest>
    <RunTest_bool>
			<ub>
				<showdoc level="public"/>
			</ub>
			<summary>
				The <see langword="RunTest"/> method is used to execute tests within a <see cref="T:UnitedBinary.UnitTests.Framework.TestMethodAttribute">test method</see>.</summary>
			<param name="assertion">A test which evaluates to a boolean value used to determine whether the test succeeded. When <paramref name="assertion"/> is <see langword="true"/> HarnessIt considers the test a success.</param>
			<remarks>
				<para>Each call to the <see langword="RunTest"/> method is considered one unit test for statistical purposes.</para>
				<para>The <see langword="RunTest"/> method is thread-safe.</para>
			</remarks>
			<returns>The value of the <paramref name="assertion"/> parameter.</returns>
			<example>
			The following example details the use of the <see langword="RunTest"/> method.
			<code>
using System;
using UnitedBinary.UnitTests.Framework;

namespace MyNamespace
{
    public class Tests
    {
        public Tests() {}

        [TestMethod]
        public void ThisIsATest(TestMethodRecord tmr)
        {
            tmr.RunTest(3+3 == 6);
            tmr.RunTest(3-3 == 0);
            tmr.RunTest(3*3 == 9);
            tmr.RunTest(3/3 == 1);
        }
    }
}</code>
			</example>
			<seealso cref="T:UnitedBinary.UnitTests.Framework.TestMethodAttribute"/>
		</RunTest_bool>
		<WriteLine>
			<ub>
				<showdoc level="public"/>
			</ub>
			<summary>
				The <see langword="WriteLine"/> method is used to add additional descriptive text to the output of a <see cref="T:UnitedBinary.UnitTests.Framework.TestMethodAttribute">test method</see>.</summary>
			<param name="message">The text to write to the HarnessIt Output pane.</param>
			<remarks>
				<para>Use the <see langword="WriteLine"/> method to annotate your test method output. <see langword="WriteLine"/> is especially helpful for printing values of variables from within your test methods.</para>
				<para>The <see langword="WriteLine"/> method is thread-safe.</para>
			</remarks>
			<seealso cref="T:UnitedBinary.UnitTests.Framework.TestMethodAttribute"/>
		</WriteLine>
		<HasRun>
			<summary>
				Determines if this TestMethodRecord has run any tests.
			</summary>
		</HasRun>
		<SignalException_string>
			<summary/>
			<param name="description"/>
		</SignalException_string>
		<SignalException_string_Type>
			<summary/>
			<param name="description"/>
			<param name="type"/>
		</SignalException_string_Type>
		<RegisterException_string>
			<ub>
				<showdoc level="public"/>
			</ub>
			<overloads>The <see langword="RegisterException"/> method allows a <see cref="T:UnitedBinary.UnitTests.Framework.TestMethodAttribute">test method</see> to end in success when an exception of the registered type is thrown.</overloads>
			<summary>
			Declares that any exception thrown by the current <see cref="T:UnitedBinary.UnitTests.Framework.TestMethodAttribute">test method</see> will be considered a successful test.
			</summary>
			<remarks>
				<para>The test method containing the call to the <see langword="RegisterException"/> method is <i>required</i> to throw an exception. If an exception is not thrown, then the test is considered a failure.</para>
				<para>This method should only be called once per test method. All subsequent calls will replace the previously registered exception settings.</para>
			</remarks>
			<example>
			This example shows how to use <see langword="RegisterException"/> to end the test method <c>GoodRegisterTest</c> in success and the test method <c>BadRegisterTest</c> in failure.
			<code>
using System;
using UnitedBinary.UnitTests.Framework;

namespace MyNamespace
{
    public class Tests
    {
        public Tests() {}

        [TestMethod]
        public void GoodRegisterTest(TestMethodRecord tmr)
        {
            tmr.RegisterException("Any exception will cause this method to end in success.");
            throw new ArgumentException("This exception was expected.");
        }

        [TestMethod]
        public void BadRegisterTest(TestMethodRecord tmr)
        {
            tmr.RegisterException("Any exception will cause this method to end in success.");

            // Since we do not throw an exception, this test method will fail.
        }
    }
}</code>
			</example>
			<param name="description">A description that will be displayed in the HarnessIt Output pane.</param>
		</RegisterException_string>
		<RegisterException_string_Type>
			<ub>
				<showdoc level="public"/>
			</ub>
			<summary>
			Declares that only an exception of a specific type thrown by the current <see cref="T:UnitedBinary.UnitTests.Framework.TestMethodAttribute">test method</see> will be considered a successful test.
			</summary>
			<remarks>
			<para>The test method containing the call to the <see langword="RegisterException"/> method is <i>required</i> to throw an exception. If an exception is not thrown, then the test is considered a failure.</para>
			<para>The thrown exception may either be of the exact type as the <paramref name="type"/> parameter or it may be derived from <paramref name="type"/>.</para>
			<para>This method should only be called once per test method. All subsequent calls will replace the previously registered exception settings.</para>
			</remarks>
			<example>
			This example shows how to use <see langword="RegisterException"/> to end the test method <c>GoodRegisterTest</c> in success and the test method <c>BadRegisterTest</c> in failure.
			<code>
using System;
using UnitedBinary.UnitTests.Framework;

namespace MyNamespace
{
    public class Tests
    {
        public Tests() {}

        [TestMethod]
        public void GoodRegisterTest(TestMethodRecord tmr)
        {
            tmr.RegisterException("Only an IllegalOperationException will cause " +
                "this method to end in success.", typeof(InvalidOperationException));
            throw new InvalidOperationException("This exception was expected.");
        }

        [TestMethod]
        public void BadRegisterTest(TestMethodRecord tmr)
        {
            tmr.RegisterException("Only an IllegalOperationException will cause " +
                "this method to end in success.", typeof(InvalidOperationException));
            throw new ArgumentException("This exception is of the wrong type.");
        }
    }
}</code>
			</example>
			<param name="description">A description that will be displayed in the HarnessIt Output pane.</param>
			<param name="type">The type of exception that the test method should throw.</param>
		</RegisterException_string_Type>
		<TestCount>
			<summary>
				The number of unit tests which have been run.
			</summary>
		</TestCount>
		<TestObjectCount>
			<summary>
				The number of TestObject objects contained in the
				TestMethodRecord.  These include TestResult
				and TestComment objects.
			</summary>
		</TestObjectCount>
		<CountTestResults>
			<summary>
				CountTestResults looks through all the TestObject objects and counts the number of TestResult objects.
			</summary>
			<returns>Number of TestResult objects.</returns>
		</CountTestResults>
		<GetResult>
			<summary>
				Gives access to the individual TestObject objects.
			</summary>
			<param name="i">The 0-based index of the TestObject object to retrieve</param>
			<returns>The TestObject object specified by the index i.</returns>
		</GetResult>
		<Successes>
			<summary>
				The number of tests which have succeeded.
			</summary>
		</Successes>
		<Failures>
			<summary>
				The number of tests which have failed.
			</summary>
		</Failures>
		<TE>
			<summary>
				The exception caught if any were thrown while running tests.
			</summary>
		</TE>
		<AddTestException>
			<summary/>
		</AddTestException>
		<TestExceptionCount>
			<summary/>
		</TestExceptionCount>
		<ExpectException>
			<summary>
				ExpectException is true if the SiganlExecption() method
				has been called, otherwise it is false.
			</summary>
		</ExpectException>
		<ExpectedExceptionMessage>
			<summary>
				The description passed to RegisterException().
			</summary>
		</ExpectedExceptionMessage>
		<ExpectedExceptionType>
			<summary>
				Expected type of exception (System.Exception by default).
			</summary>
		</ExpectedExceptionType>
		<ConsistentException>
			<summary>
				Boolean value to state whether the thrown exception (or
				lack thereof) was consistent with the expected exception
				(or lack thereof).
			</summary>
		</ConsistentException>
		<operatorPlus>
			<summary>
				Overrides the + operator to allow "addition" which essentially
				combines the test results from the two TestMethodRecords.
			</summary>
			<param name="t1">TestMethodRecord to combine</param>
			<param name="t2">TestMethodRecord to combine</param>
			<returns>TestMethodRecord which is the combination of t1 and t2</returns>
		</operatorPlus>
		<ToString>
			<summary>
				Overrides the ToString() method of this class to return
				the results as string output.
			</summary>
			<returns>String containing test results</returns>
		</ToString>
	</TestMethodRecord>
	<!-- XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX -->
	<!-- XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX -->
	<TestOrderAttribute>
		<Class>
			<ub>
				<showdoc level="public"/>
			</ub>
			<summary>
				The <see langword="TestOrderAttribute"/> is an optional attribute that allows you to control the order in which test assemblies, classes, and methods execute.
			</summary>
			<remarks>
			<para>The <see langword="TestOrderAttribute"/> class is used to order your test assemblies, classes, and methods.</para>
			<para>HarnessIt does not normally execute your test methods in the order that they are defined. Usually, this is not a problem since test methods most likely do not depend on each other. Still, there are any number of reasons why you may find it necessary to order your test methods.</para>
			</remarks>
			<example>
			The following example illustrates how to use the <see langword="TestOrderAttribute"/> class to order a group of test methods (marked by the <see cref="T:UnitedBinary.UnitTests.Framework.TestMethodAttribute"/> class).
			<code>
using System;
using UnitedBinary.UnitTests.Framework;

namespace MyNamespace
{
    public class OrderingExample
    {
        public OrderingExample() {}

        [TestOrder(TestOrderModes.Last)]
        [TestMethod("Method 1")]
        public void FirstMethod(TestMethodRecord tmr)
        {
            // This method will execute fifth because it is in the
            // Last group.
        }

        [TestOrder(TestOrderModes.First, 40)] 
        [TestMethod("Method 2")]
        public void SecondMethod(TestMethodRecord tmr)
        {
            // This method will execute first because it is in the 
            // First group and has an explicit suborder.
        }

        [TestMethod("Method 3")]
        public void ThirdMethod(TestMethodRecord tmr)
        {
            // This method may execute either third or fourth
            // because it is unordered.
        }

        [TestOrder(TestOrderModes.First)]
        [TestMethod("Method 4")]
        public void FourthMethod(TestMethodRecord tmr)
        {
            // This method will execute second because it is in the 
            // First group.
        }

        [TestMethod("Method 5")]
        public void FifthMethod(TestMethodRecord tmr)
        {
            // This method may execute either third or fourth
            // because it is unordered.
        }

        [TestOrder(TestOrderModes.Last, 3)] 
        [TestMethod("Method 6")]
        public void SixthMethod(TestMethodRecord tmr)
        {
            // This method will execute sixth because it is in the
            // Last group and has an explicit suborder.
        }
    }
}</code>
			</example>
			<seealso href="../ProgrammingTestOrder.html">Test Order and Stateful Testing</seealso>
			<seealso cref="T:UnitedBinary.UnitTests.Framework.TestOrderModes"/>
			<seealso cref="T:UnitedBinary.UnitTests.Framework.TestMethodAttribute"/>
			<seealso cref="T:System.Attribute"/>
		</Class>
		<ctor_TestOrderModes>
			<ub>
				<showdoc level="public"/>
			</ub>
			<overloads>Creates an instance of the <see cref="T:UnitedBinary.UnitTests.Framework.TestOrderAttribute"/> class.</overloads>
			<summary>
			Creates an instance of the <see cref="T:UnitedBinary.UnitTests.Framework.TestOrderAttribute"/> class and orders the marked item into a general ordering group.
			</summary>
			<remarks>
			<para>The <see cref="T:UnitedBinary.UnitTests.Framework.TestOrderAttribute"/> class makes it possible to define the order in which test methods will be invoked. Test ordering is controlled by the value of the <paramref name="mode"/> parameter that is provided when the <see langword="TestOrderAttribute"/> is specified. The <paramref name="mode"/> parameter is an enumeration of type <see cref="T:UnitedBinary.UnitTests.Framework.TestOrderModes"/> which specifies a general "bucket" into which the tests will be grouped. The value of <paramref name="mode"/> can be either <see langword="First"/>, <see langword="Last"/>, or <see langword="Neutral"/>.</para>
			<para>Test methods are ordered as follows by <paramref name="mode"/>: <see langword="First"/> executes before <see langword="Neutral"/>, and <see langword="Neutral"/> executes before <see langword="Last"/>.</para>
			<para>The <see langword="TestOrderAttribute"/> can be applied to methods, classes and assemblies. Assemblies are sorted into groups by their <paramref name="mode"/> value, then the classes within the assemblies are similarly ordered followed by the test methods within each class.</para>
			</remarks>
			<param name="mode">The ordering group into which this item will be placed.</param>
		</ctor_TestOrderModes>
		<ctor_TestOrderModes_int>
			<ub>
				<showdoc level="public"/>
			</ub>
			<summary>
			Creates an instance of the <see cref="T:UnitedBinary.UnitTests.Framework.TestOrderAttribute"/> class, places the marked item into a general ordering group, and further orders the item within the ordering group.
			</summary>
			<remarks>
			<para>The <see cref="T:UnitedBinary.UnitTests.Framework.TestOrderAttribute"/> class makes it possible to define the order in which test methods will be invoked. Test ordering is controlled by the values of the <paramref name="mode"/> and <paramref name="suborder"/> parameters that are provided when the <see langword="TestOrderAttribute"/> is specified. The <paramref name="mode"/> parameter is an enumeration of type <see cref="T:UnitedBinary.UnitTests.Framework.TestOrderModes"/> which specifies a general "bucket" into which the tests will be grouped. The value of <paramref name="mode"/> can be either <see langword="First"/>, <see langword="Last"/>, or <see langword="Neutral"/>. We further define the order with the <paramref name="suborder"/> parameter which is an integer that defines where, in relation to the group defined by the <paramref name="mode"/>, the method will be ordered. The <paramref name="suborder"/> value does not need to be either consecutive or unique -- its primary purpose is to specify a relative weight or priority for the test relative to any other tests in the same group.</para>
			<para>Test methods are ordered as follows by <paramref name="mode"/> and <paramref name="suborder"/>: <see langword="First"/> executes before <see langword="Neutral"/>, and <see langword="Neutral"/> executes before <see langword="Last"/>. Within these groups, tests execute in order of accending <paramref name="suborder"/>.</para>
			<para>The <see langword="TestOrderAttribute"/> can be applied to methods, classes and assemblies. First, assemblies are sorted into groups by their <paramref name="mode"/> values and then ordered by their <paramref name="suborder"/> values, then the classes within the assemblies are similarly ordered followed by the test methods within each class.</para>
			<para>When a method, class or assembly is ordered and its <paramref name="suborder"/> is defined, the ordered item will execute at a higher priority than any items that were simply ordered into the <see langword="First"/>, <see langword="Neutral"/> and <see langword="Last"/> buckets. The priority varies by group and is defined in the following table:</para>
			<list type="table">
			<listheader><term>Order mode (Group)</term><description>Priority</description></listheader>
			<item><term><see langword="First"/></term><description>Items with explicit <paramref name="suborder"/> values will always execute before items that do not define a <paramref name="suborder"/>.</description></item>
			<item><term><see langword="Neutral"/></term><description>Items with explicit <paramref name="suborder"/> values of less than 100 will execute before all items that do not define a <paramref name="suborder"/>. Items with <paramref name="suborder"/> values greater than 100 will execute after any items that do not declare a <paramref name="suborder"/>.</description></item>
			<item><term><see langword="Last"/></term><description>Items with explicit <paramref name="suborder"/> values will always execute after items that do not define a <paramref name="suborder"/>.</description></item>
			</list>
			</remarks>
			<param name="mode">The ordering group into which this item will be placed.</param>
			<param name="suborder">The relative ordering to apply to this item within the ordering group specified by <paramref name="mode"/>.</param>
		</ctor_TestOrderModes_int>
		<ctor_string_TestOrderModes>
			<summary/>
			<param name="description"/>
			<param name="mode"/>
		</ctor_string_TestOrderModes>
		<ctor_string_TestOrderModes_int>
			<summary/>
			<param name="description"/>
			<param name="mode"/>
			<param name="suborder"/>
		</ctor_string_TestOrderModes_int>
<!--	<Description>
			<summary>
				Gets the attribute's description.
			</summary>
		</Description>-->
		<Mode>
			<summary>
				Gets the attribute's TestOrderMode.
			</summary>
		</Mode>
		<SubModeOrder>
			<summary>
				Gets the attribute's suborder.
			</summary>
		</SubModeOrder>
	</TestOrderAttribute>
	<!-- XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX -->
	<!-- XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX -->
	<TestOrderModes>
		<Class>
			<ub>
				<showdoc level="public"/>
			</ub>
			<summary>
				The <see langword="TestOrderModes"/> enumeration defines the primary weightings that can be applied to test assemblies, classes and methods.
			</summary>
			<remarks>
			Use the <see langword="TestOrderModes"/> with the <see cref="T:UnitedBinary.UnitTests.Framework.TestOrderAttribute"/> to order the execution of test assemblies, classes and methods.
			</remarks>
		</Class>
		<First>
			<ub>
				<showdoc level="public"/>
			</ub>
			<summary>
			<para>The ordered item will be executed <i>before</i> any unordered items or items ordered <see langword="Neutral"/> or <see langword="Last"/>.</para>
			</summary>
		</First>
		<Last>
			<ub>
				<showdoc level="public"/>
			</ub>
			<summary>
			<para>The ordered item will be executed <i>after</i> any unordered items or items ordered <see langword="First"/> or <see langword="Neutral"/>.</para>
			</summary>
		</Last>
		<Neutral>
			<ub>
				<showdoc level="public"/>
			</ub>
			<summary>
			<para>The ordered item will be executed <i>after</i> any items ordered <see langword="First"/> and <i>before</i> any items ordered as <see langword="Last"/>.</para>
			<para><see langword="Neutral"/> is the default general ordering for any test items that are not explicitly ordered by the <see cref="T:UnitedBinary.UnitTests.Framework.TestOrderAttribute"/>.</para>
			</summary>
		</Neutral>
	</TestOrderModes>
	<!-- XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX -->
	<!-- XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX -->
	<TestRequiredAttribute>
		<Class>
			<ub>
				<showdoc level="public"/>
			</ub>
			<summary>
			Test methods marked with the optional <see langword="TestRequiredAttribute"/> are always executed and can not be selected or deselected within the HarnessIt user interface.
			</summary>
			<remarks>
			<para><see cref="T:UnitedBinary.UnitTests.Framework.TestMethodAttribute">Test methods</see> marked with the optional <see langword="TestRequiredAttribute"/> will always be displayed as unchecked in the HarnessIt tree view and will have a background color of pale goldenrod. Any classes or assemblies containing required methods will also have a background color of pale goldenrod so they can be quickly recognized in the HarnessIt tree view.</para>
			</remarks>
			<example>
			The following example shows the code necessary to apply the <see langword="TestRequiredAttribute"/> to a method.
			<code>
using System;
using UnitedBinary.UnitTests.Framework;

namespace MyNamespace
{
    public class Tests
    {
        public Tests() {}

        [TestMethod("This is a standard test method.")]
        public void NormalTestMethod(TestMethodRecord tmr)
        {
            tmr.RunTest(2+2 == 4, "Addition works.");
        }

        [TestRequired]
        [TestMethod("This test method can never be disabled.")]
        public void RequiredTestMethod(TestMethodRecord tmr)
        {
            tmr.RunTest(2-2 == 0, "Subtraction works.");
        }
    }
}</code>
			</example>
			<seealso cref="T:System.Attribute"/>
		</Class>
		<ctor>
			<ub>
				<showdoc level="public"/>
			</ub>
			<summary>
				Creates an instance of the <see cref="T:UnitedBinary.UnitTests.Framework.TestRequiredAttribute"/> class.
			</summary>
			<remarks>
			<para><see cref="T:UnitedBinary.UnitTests.Framework.TestMethodAttribute">Test methods</see> marked with the optional <see cref="T:UnitedBinary.UnitTests.Framework.TestRequiredAttribute"/> will always be displayed as unchecked in the HarnessIt tree view and will have a background color of pale goldenrod. Any classes or assemblies containing required methods will also have a background color of pale goldenrod so they can be quickly recognized in the HarnessIt tree view.</para>
			<para>
			Specifying <see langword="TestRequiredAttribute"/> on a method is not required.
			</para>
			</remarks>
			<example>
			The following example shows the code necessary to apply the <see cref="T:UnitedBinary.UnitTests.Framework.TestRequiredAttribute"/> to a method.
			<code>
using System;
using UnitedBinary.UnitTests.Framework;

namespace MyNamespace
{
    public class Tests
    {
        public Tests() {}

        [TestMethod("This is a standard test method.")]
        public void NormalTestMethod(TestMethodRecord tmr)
        {
            tmr.RunTest(2+2 == 4, "Addition works.");
        }

        [TestRequired]
        [TestMethod("This test method can never be disabled and will always execute.")]
        public void RequiredTestMethod(TestMethodRecord tmr)
        {
            tmr.RunTest(2-2 == 0, "Subtraction works.");
        }
    }
}</code>
			</example>
			<seealso cref="T:UnitedBinary.UnitTests.Framework.TestMethodAttribute"/>
		</ctor>
	</TestRequiredAttribute>
	<!-- XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX -->
	<!-- XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX -->
</Docs>